/*-------------------------------------------------------------------------
 *
 * tlist.c--
 *    Target list manipulation routines
 *
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    $Header: /usr/local/cvsroot/postgres95/src/backend/optimizer/util/tlist.c,v 1.1.1.1 1996/07/09 06:21:39 scrappy Exp $
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"

#include "nodes/relation.h"
#include "nodes/primnodes.h"
#include "nodes/pg_list.h"
#include "nodes/nodeFuncs.h"
#include "utils/elog.h"
#include "utils/lsyscache.h"

#include "optimizer/internal.h"
#include "optimizer/var.h"
#include "optimizer/tlist.h"
#include "optimizer/clauses.h"

#include "nodes/makefuncs.h"
#include "parser/catalog_utils.h"

static Node *flatten_tlistentry(Node *tlistentry, List *flat_tlist);

/*****************************************************************************
 *  ---------- RELATION node target list routines ----------
 *****************************************************************************/

/*    
 * tlistentry-member--
 *    
 * RETURNS:  the leftmost member of sequence "targetlist" that satisfies
 *           the predicate "var_equal"
 * MODIFIES: nothing
 * REQUIRES: test = function which can operate on a lispval union
 *           var = valid var-node
 *	     targetlist = valid sequence
 */
TargetEntry *
tlistentry_member(Var *var, List *targetlist)
{
    if (var) {
	List *temp = NIL;

	foreach (temp,targetlist) {
	    if (var_equal(var,
			  get_expr(lfirst(temp))))
		return((TargetEntry*)lfirst(temp));
	}
    }
    return (NULL);
}

/*    
 * matching_tlvar--
 *    
 * RETURNS:  var node in a target list which is var_equal to 'var',
 *    	     if one exists.
 * REQUIRES: "test" operates on lispval unions,
 * 
 */
Expr *
matching_tlvar(Var *var, List *targetlist)
{
    TargetEntry *tlentry;

    tlentry = tlistentry_member(var,targetlist);
    if (tlentry) 
	return((Expr*)get_expr (tlentry) );

    return((Expr*) NULL);
}

/*    
 * add_tl_element--
 *    Creates a targetlist entry corresponding to the supplied var node
 *
 * 'var' and adds the new targetlist entry to the targetlist field of
 * 'rel' 
 *    
 * RETURNS: nothing
 * MODIFIES: vartype and varid fields of leftmost varnode that matches
 *           argument "var" (sometimes).
 * CREATES:  new var-node iff no matching var-node exists in targetlist
 */
void
add_tl_element(Rel *rel, Var *var)
{
    Expr *oldvar = (Expr *)NULL;
    
    oldvar = matching_tlvar(var, rel->targetlist);
    
    /*
     * If 'var' is not already in 'rel's target list, add a new node. 
     */
    if (oldvar==NULL) {
	List *tlist = rel->targetlist;
	Var *newvar = makeVar(var->varno,
			      var->varattno,
			      var->vartype,
			      var->varno,
			      var->varoattno);

	rel->targetlist =
	    lappend (tlist,
		      create_tl_element(newvar,
					length(tlist) + 1));

    }
}

/*    
 * create_tl_element--
 *    Creates a target list entry node and its associated (resdom var) pair
 *    with its resdom number equal to 'resdomno' and the joinlist field set
 *    to 'joinlist'.
 *    
 * RETURNS:  newly created tlist-entry
 * CREATES:  new targetlist entry (always).
 */
TargetEntry*
create_tl_element(Var *var, int resdomno)
{
    TargetEntry *tlelement= makeNode(TargetEntry);
    
    tlelement->resdom =
	makeResdom(resdomno, 
		   var->vartype,
		   get_typlen(var->vartype),
		   NULL,
		   (Index)0,
		   (Oid)0,
		   0);
    tlelement->expr = (Node*)var;
    
    return(tlelement);
}

/*    
 * get-actual-tlist--
 *    Returns the targetlist elements from a relation tlist.
 *    
 */
List *
get_actual_tlist(List *tlist)
{
    /*
     * this function is not making sense. - ay 10/94
     */
#if 0 
    List *element = NIL;
    List *result = NIL;
    
    if (tlist==NULL) {
	elog(DEBUG,"calling get_actual_tlist with empty tlist");
	return(NIL);
    }
    /* XXX - it is unclear to me what exactly get_entry 
       should be doing, as it is unclear to me the exact
       relationship between "TL" "TLE" and joinlists */

    foreach(element,tlist)
	result = lappend(result, lfirst((List*)lfirst(element)));
    
    return(result);
#endif
    return tlist;
}

/*****************************************************************************
 *    	---------- GENERAL target list routines ----------
 *****************************************************************************/

/*    
 * tlist-member--
 *    Determines whether a var node is already contained within a
 *    target list.
 *    
 * 'var' is the var node
 * 'tlist' is the target list
 * 'dots' is t if we must match dotfields to determine uniqueness
 *    
 * Returns the resdom entry of the matching var node.
 *    
 */
Resdom *
tlist_member(Var *var, List *tlist)
{
    List *i = NIL;
    TargetEntry *temp_tle = (TargetEntry *)NULL;
    TargetEntry *tl_elt = (TargetEntry *)NULL;

    if (var) {
	foreach (i,tlist) {
	    temp_tle = (TargetEntry *)lfirst(i);
	    if (var_equal(var, get_expr(temp_tle))) {
		tl_elt = temp_tle;
		break;
	    }
	}

	if (tl_elt != NULL)
	    return(tl_elt->resdom);
	else 
	    return((Resdom*)NULL);
    }
    return ((Resdom*)NULL);
}

/*
 *   Routine to get the resdom out of a targetlist.
 */
Resdom *
tlist_resdom(List *tlist, Resdom *resnode)
{
    Resdom *resdom = (Resdom*)NULL;
    List *i = NIL;
    TargetEntry *temp_tle = (TargetEntry *)NULL;

    foreach(i,tlist) {
	temp_tle = (TargetEntry *)lfirst(i);
	resdom = temp_tle->resdom;
	/*  Since resnos are supposed to be unique */
	if (resnode->resno == resdom->resno)  
	    return(resdom);
    }
    return((Resdom*)NULL);
}


/*    
 * match_varid--
 *    Searches a target list for an entry with some desired varid.
 *    
 * 'varid' is the desired id
 * 'tlist' is the target list that is searched
 *    
 * Returns the target list entry (resdom var) of the matching var.
 *
 * Now checks to make sure array references (in addition to range
 * table indices) are identical - retrieve (a.b[1],a.b[2]) should
 * not be turned into retrieve (a.b[1],a.b[1]).
 *    
 * [what used to be varid is now broken up into two fields varnoold and
 *  varoattno. Also, nested attnos are long gone. - ay 2/95]
 */
TargetEntry *
match_varid(Var *test_var, List *tlist)
{
    List *tl;
    Oid type_var;

    type_var = (Oid) test_var->vartype;

    foreach (tl, tlist) {
	TargetEntry *entry;
	Var *tlvar;

	entry = lfirst(tl);
	tlvar = get_expr(entry);

	/*
	 * we test the original varno (instead of varno which might
	 * be changed to INNER/OUTER.
	 */
	if (tlvar->varnoold == test_var->varnoold &&
	    tlvar->varoattno == test_var->varoattno) {

	    if (tlvar->vartype == type_var)
		return(entry);
	}
    }

    return (NULL);
}


/*    
 * new-unsorted-tlist--
 *    Creates a copy of a target list by creating new resdom nodes
 *    without sort information.
 *    
 * 'targetlist' is the target list to be copied.
 *    
 * Returns the resulting target list.
 *    
 */
List *
new_unsorted_tlist(List *targetlist)
{
    List *new_targetlist = (List*)copyObject ((Node*)targetlist);
    List *x = NIL;

    foreach (x, new_targetlist) {
	TargetEntry *tle = (TargetEntry *)lfirst(x);
	tle->resdom->reskey = 0;
	tle->resdom->reskeyop = (Oid)0;
    }
    return(new_targetlist);
}

/*    
 * copy-vars--
 *    Replaces the var nodes in the first target list with those from
 *    the second target list.  The two target lists are assumed to be
 *    identical except their actual resdoms and vars are different.
 *    
 * 'target' is the target list to be replaced
 * 'source' is the target list to be copied
 *    
 * Returns a new target list.
 *    
 */
List *
copy_vars(List *target, List *source)
{
    List *result = NIL;
    List *src = NIL;
    List *dest = NIL;
    
    for ( src = source, dest = target; src != NIL &&
	 dest != NIL; src = lnext(src), dest = lnext(dest)) {
	TargetEntry *temp = MakeTLE(((TargetEntry *)lfirst(dest))->resdom,
				 (Node*)get_expr(lfirst(src)));
	result = lappend(result,temp);
    }
    return(result);
}

/*    
 * flatten-tlist--
 *    Create a target list that only contains unique variables.
 *
 *
 * 'tlist' is the current target list
 *    
 * Returns the "flattened" new target list.
 *    
 */
List *
flatten_tlist(List *tlist)
{
    int last_resdomno = 1;
    List *new_tlist = NIL;
    List *tlist_vars = NIL;
    List *temp;

    foreach (temp, tlist)  {
	TargetEntry *temp_entry = NULL;
	List *vars;

	temp_entry = lfirst(temp);
	vars = pull_var_clause((Node*)get_expr(temp_entry));
	if(vars != NULL) {
	    tlist_vars = nconc(tlist_vars, vars);
	}
    }

    foreach (temp, tlist_vars) {
	Var *var = lfirst(temp);
	if (!(tlist_member(var, new_tlist))) {
	    Resdom *r;

	    r = makeResdom(last_resdomno,
			   var->vartype,
			   get_typlen(var->vartype),
			   NULL,
			   (Index)0,
			   (Oid)0,
			   0);
	    last_resdomno++;
	    new_tlist = lappend(new_tlist, MakeTLE (r, (Node*)var));
	}
    }

    return new_tlist;
}

/*    
 * flatten-tlist-vars--
 *    Redoes the target list of a query with no nested attributes by
 *    replacing vars within computational expressions with vars from
 *    the 'flattened' target list of the query.
 *    
 * 'full-tlist' is the actual target list
 * 'flat-tlist' is the flattened (var-only) target list
 *    
 * Returns the modified actual target list.
 *    
 */
List *
flatten_tlist_vars(List *full_tlist, List *flat_tlist)
{
    List *x = NIL;
    List *result = NIL;
    
    foreach(x,full_tlist) {
	TargetEntry *tle= lfirst(x);
	result =
	    lappend(result,
		     MakeTLE(tle->resdom,
			     flatten_tlistentry((Node*)get_expr(tle),
						flat_tlist)));
    }

    return(result);
}

/*    
 * flatten-tlistentry--
 *    Replaces vars within a target list entry with vars from a flattened
 *    target list.
 *    
 * 'tlistentry' is the target list entry to be modified
 * 'flat-tlist' is the flattened target list
 *    
 * Returns the (modified) target_list entry from the target list.
 *    
 */
static Node *
flatten_tlistentry(Node *tlistentry, List *flat_tlist)
{
    if (tlistentry==NULL) {

	return NULL;

    } else if (IsA (tlistentry,Var)) {

	return
	    ((Node *)get_expr(match_varid((Var*)tlistentry,
					  flat_tlist)));
    } else if (IsA (tlistentry,Iter)) {

	((Iter*)tlistentry)->iterexpr = 
	    flatten_tlistentry((Node*)((Iter*)tlistentry)->iterexpr,
			       flat_tlist);
	return tlistentry;

    } else if (single_node(tlistentry)) {

	return tlistentry;

    } else if (is_funcclause (tlistentry)) {
	Expr *expr = (Expr*)tlistentry;
	List *temp_result = NIL;
	List *elt = NIL;
	
	foreach(elt, expr->args)
	    temp_result = lappend(temp_result,
				   flatten_tlistentry(lfirst(elt),flat_tlist));
	
	return
	    ((Node *)make_funcclause((Func*)expr->oper, temp_result));

    } else if (IsA(tlistentry,Aggreg)) {

	return tlistentry;

    } else if (IsA(tlistentry,ArrayRef)) {
	ArrayRef *aref = (ArrayRef *)tlistentry;
	List *temp = NIL;
	List *elt = NIL;

	foreach(elt, aref->refupperindexpr)
	    temp = lappend(temp, flatten_tlistentry(lfirst(elt), flat_tlist));
	aref->refupperindexpr = temp;

	temp = NIL;
	foreach(elt, aref->reflowerindexpr)
	    temp = lappend(temp, flatten_tlistentry(lfirst(elt), flat_tlist));
	aref->reflowerindexpr = temp;

	aref->refexpr = 
	    flatten_tlistentry(aref->refexpr, flat_tlist);

	aref->refassgnexpr = 
	    flatten_tlistentry(aref->refassgnexpr, flat_tlist);

	return tlistentry;
    } else {
	Expr *expr = (Expr*)tlistentry;
	Var *left =
	    (Var*)flatten_tlistentry((Node*)get_leftop(expr),
				     flat_tlist);
	Var *right =
	    (Var*)flatten_tlistentry((Node*)get_rightop(expr),
				     flat_tlist);

	return((Node *)
	       make_opclause((Oper*)expr->oper, left, right));
    }
}


TargetEntry *
MakeTLE(Resdom *resdom, Node *expr)
{
    TargetEntry *rt = makeNode(TargetEntry);

    rt->resdom = resdom;
    rt->expr = expr;
    return rt;
}

Var *
get_expr(TargetEntry *tle)
{
    Assert(tle!=NULL);
    Assert(tle->expr!=NULL);

    return ((Var *)tle->expr); 
}


/*****************************************************************************
 *
 *****************************************************************************/

/*
 * AddGroupAttrToTlist -
 *    append the group attribute to the target list if it's not already
 *    in there.
 */
void
AddGroupAttrToTlist(List *tlist, List *grpCl)
{
    List *gl;
    int last_resdomno = length(tlist) + 1;
    
    foreach (gl, grpCl) {
	GroupClause *gc = (GroupClause*)lfirst(gl);
	Var *var = gc->grpAttr;

	if (!(tlist_member(var, tlist))) {
	    Resdom *r;

	    r = makeResdom(last_resdomno,
			   var->vartype,
			   get_typlen(var->vartype),
			   NULL,
			   (Index)0,
			   (Oid)0,
			   0);
	    last_resdomno++;
	    tlist = lappend(tlist, MakeTLE(r, (Node*)var));
	}
    }
}

/* was ExecTargetListLength() in execQual.c, 
   moved here to reduce dependencies on the executor module */
int
exec_tlist_length(List *targetlist)
{
    int len;
    List *tl;
    TargetEntry *curTle;
    
    len = 0;
    foreach (tl, targetlist) {
	curTle = lfirst(tl);
	
	if (curTle->resdom != NULL)
	    len++;
    }
    return len;
}


